package rtool

import (
	"cmp"
	"strconv"
)

// IgnoreOne 忽略第一个参数，直接返回第二个参数。
func IgnoreOne[T1 any, T2 any](_t1 T1, _t2 T2) T2 {
	return _t2
}

// IgnoreTwo 忽略第二个参数，直接返回第一个参数。
func IgnoreTwo[T1 any, T2 any](_t1 T1, _t2 T2) T1 {
	return _t1
}

func Pointer[T cmp.Ordered](val T) *T {
	return &val
}

func PointerInt(i int) *int {
	return &i
}

func PointerUint(i uint) *uint {
	return &i
}

func PointerInt32(i int32) *int32 {
	return &i
}

func PointerInt64(i int64) *int64 {
	return &i
}

func PointerFloat32(i float32) *float32 {
	return &i
}

func PointerFloat64(i float64) *float64 {
	return &i
}

func PointerString(str string) *string {
	return &str
}

func PointerFalse() *bool {
	var _bl = false
	return &_bl
}

func PointerTrue() *bool {
	var _bl = true
	return &_bl
}

func StrToInt(str string) int {
	i, err := strconv.Atoi(str)
	if err != nil {
		return 0
	}
	return i
}

func StrToInt32(str string) int32 {
	i, err := strconv.Atoi(str)
	if err != nil {
		return 0
	}
	return int32(i)
}

func StrToInt64(str string) int64 {
	i, err := strconv.ParseInt(str, 10, 64)
	if err != nil {
		return 0
	}
	return i
}

func StrToUint(str string) uint {
	i, err := strconv.ParseUint(str, 10, 64)
	if err != nil {
		return 0
	}
	return uint(i)
}

func StrToUint32(str string) uint32 {
	i, err := strconv.ParseUint(str, 10, 32)
	if err != nil {
		return 0
	}
	return uint32(i)
}

func StrToUint64(str string) uint64 {
	i, err := strconv.ParseUint(str, 10, 32)
	if err != nil {
		return 0
	}
	return uint64(i)
}

func StrToFloat32(str string) float32 {
	i, err := strconv.ParseFloat(str, 32)
	if err != nil {
		return 0
	}
	return float32(i)
}

func StrToFloat64(str string) float64 {
	i, err := strconv.ParseFloat(str, 64)
	if err != nil {
		return 0
	}
	return i
}

func StrToBool(str string) bool {
	i, _ := strconv.ParseBool(str)
	return i
}
